# -*- coding: utf-8 -*-
from plot import *

def intersectionAbscisses(d):
	"""
	Entrée : une droite du plan (tuple a,b,c)
	Sortie : le point d'intersection entre la droite et OX
	"""

	a, b, c = d
	return float(c)/a


def coefficientAngulaire(d):
	"""
	Entrée : une droite du plan (tuple a,b,c)
	Sortie : le coefficient angulaire de la droite d
	"""
	
	a, b, c = d
	return -float(a)/b


def droiteParallele(d, p):
	"""
	Entrée : une droite du plan (tuple a,b,c) et un point du plan (tuple x,y)
	Sortie : une droite parallèle à la première passant par le plan (tuple a,b,c)
	"""
	
	#Calcul de la pente de la droite parallèle (idem)
	m = coefficientAngulaire(d)
	#Calcul du terme indépendant dans y=mx+p
	#(on sait que p appartient à la parallèle)
	#Par retournement de l'équation, p = y-mx
	x, y = p
	p = y - m*x
	#Conversion en a,b,c (ax+by=c)
	return (m, -1, -p)


def confondues(d1, d2):
	if paralleles(d1,d2)==False:
		return
	a, b, c = d1
	d, e, f = d2
	if a==0:
		#on cherche un y tel que...
		x = 42
		#TODO (b ne sera pas nul, sinon pas une droite)
	else:
		#on cherche un x tel que...

def verifierPara(p1, p2, p3, p4):
	"""
	Entrée : 4 points d'un parallélogramme dans le plan (tuples x,y)
	Sortie : booléen
	"""
	
	#On vérifie les distances deux à deux.
	return (distancePoints(p1,p2) == distancePoints(p3,p4)) and (distancePoints(p1,p3) == distancePoints(p2,p4))


def distancePoints(p1, p2):
	"""
	Entrée : deux points du plan (tuples x,y)
	Sortie : distance
	"""
	
	a, b = p1
	c, d = p2
	return ((c-a)**2+(d-b)**2)**.5


def distanceDroitePoint(d, p):
	"""
	Entrée : une droite du plan (tuple a,b,c) et un point du plan (tuple x,y)
	Sortie : les coordonnées de l'image de p par la sym ortho d'axe d
	"""
	
	ppd = droiteNormale(d, p)
	inter = intersection(ppd, d)
	return distancePoints(inter, p)


def symetrieOrthogonale(d, p):
	"""
	Entrée : une droite du plan (tuple a,b,c) et un point du plan (tuple x,y)
	Sortie : les coordonnées de l'image de p par la sym ortho d'axe d
	"""
	
	ppd = droiteNormale(d, p)
	pX, pY = p
	iX, iY = intersection(ppd, d)
	return (2*iX-pX, 2*iY-pY)


def droiteNormale(d, p):
	"""
	Entrée : une droite du plan (tuple a,b,c) et un point du plan (tuple x,y)
	Sortie : une droite normale à d passant par p
	"""
	
	#Lecture des coefficients
	a, b, c = d
	x, y = p
	
	#Calcul du vecteur normal de la ppd
	d = -b
	e = a
	#Calcul du terme indépendant
	f = d*x + e*y
	return (d, e, f)


def intersection(d1, d2):
	"""
	Entrée : deux droites du plan (tuples a,b,c)
	Sortie : point d'intersection dans le plan (tuple x,y)
	"""
	
	#Lecture des coefficients
	a, b, c = d1
	d, e, f = d2
	
	#On va calculer ça par Cramer (déterminants)
	delta = a*e-d*b
	if delta==0:
		return #pas d'intersection...
	return (float(c*e-f*b)/delta, float(a*f-d*c)/delta)


def paralleles(d1, d2):
	"""
	Entrée : deux droites du plan (tuples a,b,c)
	Sortie : booléen
	"""
	
	#Lecture des coefficients
	a, b, c = d1
	d, e, f = d2
	
	#Par Cramer, on sait que le déterminant de la matrice sera nul
	#quand les droites sont parallèles.
	return (a*e-d*b) == 0


def appartient(d, p):
	"""
	Entrée : une droite (tuple a,b,c) et un point du plan
	Sortie : booléen
	"""
	
	a, b, c = d
	x, y = p
	return (a*x+b*y-c)==0


def droite(p1, p2):
	"""
	Entrée : p1 et p2, deux points du plan
	Sortie : un tuple avec a,b,c (ax+by=c)
	"""
	
	#Si p1=p2, il y a plus d'une droite qui passent par là...
	if p1==p2:
		return
	
	#Lecture des coordonnées
	a, b = p1
	c, d = p2
	
	#Par transformation de l'équation de droite,
	#on obtient -dy*x + dx*y = b*dx - a*dy
	dx = c-a #delta x
	mdy = b-d #-delta y
	
	return (mdy, dx, b*dx+a*mdy)
